package daemon

import (
	"fmt"
	"strconv"
	"strings"
	"time"

	"go.uber.org/zap"
	"gitee.com/liumou_site/ssh-go-automatic-upgrade/internal/config"
)

// TimeChecker 时间检查器
type TimeChecker struct {
	upgradeTime string
}

// NewTimeChecker 创建时间检查器
func NewTimeChecker(upgradeTime string) *TimeChecker {
	return &TimeChecker{
		upgradeTime: upgradeTime,
	}
}

// IsInUpgradeTimeWindow 检查当前时间是否在允许的升级时间区间内
func (tc *TimeChecker) IsInUpgradeTimeWindow() bool {
	// 如果未设置升级时间，默认允许升级
	if tc.upgradeTime == "" {
		return true
	}

	// 解析时间区间格式 HH:MM:SS-HH:MM:SS
	parts := strings.Split(tc.upgradeTime, "-")
	if len(parts) != 2 {
		zap.L().Warn("无效的升级时间格式，使用默认允许升级", zap.String("upgradeTime", tc.upgradeTime))
		return true
	}

	startTimeStr := strings.TrimSpace(parts[0])
	endTimeStr := strings.TrimSpace(parts[1])

	// 解析开始时间
	startTime, err := tc.parseTime(startTimeStr)
	if err != nil {
		zap.L().Warn("解析开始时间失败，使用默认允许升级", zap.Error(err))
		return true
	}

	// 解析结束时间
	endTime, err := tc.parseTime(endTimeStr)
	if err != nil {
		zap.L().Warn("解析结束时间失败，使用默认允许升级", zap.Error(err))
		return true
	}

	// 获取当前时间
	now := time.Now()
	currentTime := time.Date(0, 1, 1, now.Hour(), now.Minute(), now.Second(), 0, time.UTC)

	// 检查是否在时间区间内
	if startTime.Before(endTime) {
		// 正常时间区间（同一天内）
		return currentTime.After(startTime) && currentTime.Before(endTime)
	} else {
		// 跨天时间区间（如 22:00:00-06:00:00）
		return currentTime.After(startTime) || currentTime.Before(endTime)
	}
}

// parseTime 解析时间字符串（格式：HH:MM:SS）
func (tc *TimeChecker) parseTime(timeStr string) (time.Time, error) {
	parts := strings.Split(timeStr, ":")
	if len(parts) != 3 {
		return time.Time{}, fmt.Errorf("时间格式错误: %s", timeStr)
	}

	hour, err := strconv.Atoi(parts[0])
	if err != nil || hour < 0 || hour > 23 {
		return time.Time{}, fmt.Errorf("无效的小时: %s", parts[0])
	}

	minute, err := strconv.Atoi(parts[1])
	if err != nil || minute < 0 || minute > 59 {
		return time.Time{}, fmt.Errorf("无效的分钟: %s", parts[1])
	}

	second, err := strconv.Atoi(parts[2])
	if err != nil || second < 0 || second > 59 {
		return time.Time{}, fmt.Errorf("无效的秒: %s", parts[2])
	}

	return time.Date(0, 1, 1, hour, minute, second, 0, time.UTC), nil
}

// GetCurrentTimeInfo 获取当前时间信息
func (tc *TimeChecker) GetCurrentTimeInfo() string {
	now := time.Now()
	return fmt.Sprintf("当前时间: %s", now.Format("2006-01-02 15:04:05"))
}

// GetUpgradeTimeWindow 获取升级时间窗口信息
func (tc *TimeChecker) GetUpgradeTimeWindow() string {
	if tc.upgradeTime == "" {
		return "升级时间窗口: 全天允许"
	}
	return fmt.Sprintf("升级时间窗口: %s", tc.upgradeTime)
}

// ValidateTimeRange 验证时间区间格式
func (tc *TimeChecker) ValidateTimeRange() error {
	if tc.upgradeTime == "" {
		return nil
	}

	parts := strings.Split(tc.upgradeTime, "-")
	if len(parts) != 2 {
		return fmt.Errorf("时间区间格式错误，应为 HH:MM:SS-HH:MM:SS")
	}

	startTimeStr := strings.TrimSpace(parts[0])
	endTimeStr := strings.TrimSpace(parts[1])

	if _, err := tc.parseTime(startTimeStr); err != nil {
		return fmt.Errorf("开始时间格式错误: %v", err)
	}

	if _, err := tc.parseTime(endTimeStr); err != nil {
		return fmt.Errorf("结束时间格式错误: %v", err)
	}

	return nil
}

// CreateDefaultTimeChecker 创建默认时间检查器
func CreateDefaultTimeChecker() *TimeChecker {
	return NewTimeChecker(config.DefaultUpgradeTime)
}